import java.sql.DatabaseMetaData;

/**
 * Created with IntelliJ IDEA
 * Description
 * User:user
 * Date:2021-10-19
 * Time:11:40
 */


//面向对象编程思想的三个主要特征：
//继承 封装 多态 组合
//什么是封装：字段和方法都被一个private修饰，此时就说把这个字段或者方法进行了封装
//问题：public private 访问权限修饰符
//写代码的时候将有些属性设置为private
//被private修饰的字段只能在当前类中使用不在其他类进行使用
//封装的特点：安全 类的设计着调用者  降低了对类的使用成本


class Dog{
    private String name;
    public int age;
    public char sex;
    //this代表当前对象的引用
    public void setName(String name){
        this.name = name;
    }
   /* public void setName(String name){
        name = name;//自己给自己赋值
    }*/

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getName(){
        return name;
    }

}



//类的成员：
//字段，属性，成员变量：在类的内部方法的外部
//成员变量分为：普通成员变量，静态成员变量(类变量)
// (当前成员变量被static修饰,访问的时候使用类名.成员变量进行访问，静态的好处是，不需要实例化对象)
//静态的成员变量不存在对象里面，在方法区
//方法：
//二维数组
//类和对象
//类的成员：1.字段，属性，成员变量，类的内部方法的外部
//         2.方法，成员方法


    //static修饰的变量是放在方法区
    //局部变量是放在栈
    //成员变量放在堆中
    //final修饰无关变量的存储

//一个类只能有一个public类
class Person{
    //字段 属性 成员变量，定义在类的内部，方法的外部
//    public String name = "bit";
////    public int age = 18;
    //不建议一开始就行初始化
    //方法 行为 成员方法 类的行为
    public String name;
    public int age;
    public static int count = 10;
    int[] arry = new int[10];//存放在堆中不是在栈上
    public void eat(){
        System.out.println(name+"吃饭");
    }
    //在普通的成员方法中不可以定义一个静态的成员变量
    //sleep()方法要被调用，Person person = new Person();p.sleep();
    //静态的通过类名可以调用
    //如果在方法的内部是一个局部变量，局部变量的作用是在方法的内部，如果是在static修饰的你又想全局可见
    //在普通方法中可以调用静态方法
    //但是在静态方法中不可以调用普通方法
    public void sleep(){
        //static int = 999;错误
        fun();
        System.out.println(name + "睡觉");
    }
    //静态方法的内部不可以调用普通的成员方法
    //因为Person.fun() Person p = new Person()
    //静态方法的本身调用是不依赖于对象的
    //静态方法中不可以使用非静态的数据成员和非静态的方法
    //静态方法中可以使用普通的成员变量
    //普通方法中可以使用静态方法，但是不能使用静态变量
    public static void fun(){
        int a = 10;//在静态方法中可以定义一个普通变量
        System.out.println("静态方法执行了");

    }
}

class Cat{
    public String name;
    public int age;
    public char sex;
    public void  eat(){
        System.out.println(name+"吃");
    }
    public void sleep(){
        System.out.println(name+"睡觉");
    }
    public void jump(){
        System.out.println(name+"跳");
    }
   /* public  void show(){
        System.out.println("姓名："+name+" 年龄:"+age+" 性别:"+sex);
    }*/
   //自己实现一个toString方法

    //方法的重写
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}
public class TestDemo {


    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("汪汪");
        System.out.println(dog.getName());
    }
    public static void main13(String[] args) {
        Cat cat1 = new Cat();
        cat1.name = "小猫";
        cat1.eat();
        cat1.sleep();
        cat1.jump();
        //cat1.show();
        System.out.println(cat1);//打印的是这个引用的类型和地址
    }

    public static void main12(String[] args) {
        Person.fun();
        Person person = new Person();
        person.sleep();
    }

    public static void main11(String[] args) {
        //不用创建对象也可以直接使用不需要实例化对象
        System.out.println(Person.count);
        Person person= null;
        System.out.println(person.count);//不指向任何的对象仍然不会报错
        System.out.println(((Person)null).count);//也是不会报错的，静态不需要对象

    }



    public static void main10(String[] args) {
        Person person = new Person();
        //System.out.println(person.count);不会报错但是一般不推荐使用
        System.out.println(Person.count);//一般推荐使用的是类名.count
    }


    public static void main9(String[] args) {
        Person person = new Person();
        Person person2 = person;
        //Person person = new Person();//不指向任何的对象
        //person2引用指向的是person1引用指向的对象
        //进入数据结构之后这样类似的代码有很多
        //引用变量一定是在栈上吗
        //不是的，在不在栈上，取决于你是不是局部变量，成员变量是存储在堆上的
        //一个引用可以指向多个对象吗？不可以的只可以指向最后一个创建的对象，不可以只能保存一个对象的地址


    }


    public static void main7(String[] args) {
        Person person = null;//不指向任何对象
        //person.name = "haha";//空指针异常
        System.out.println(person.name);
    }

    //实例化对象，用类创建类的对象的过程就是实例化
    public static void main6(String[] args) {
        Person person1 = new Person();
        //person为引用变量
        //person是在栈上开辟的内存，在堆上会创建一个person，类中的方法存放在方法区
        //System.out.println(person1);
        person1.name = "杭凯旋";
        person1.age = 22;
        //类型.属性
        person1.sleep();
        person1.eat();
        System.out.println(person1.name);
        System.out.println(person1.age);


        Person person2 = new Person();
        person2.name = "李宁";
        person2.age = 15;
        System.out.println(person2.age);
        System.out.println(person2.name);
    }

    //类和对象的学习
    //什么是类什么是对象
    //java是面向对象的语言？什么是面向对象？
    //面向过程和面向对象的区别
    //1.买手机的过程->打开淘宝->搜索要买的手机的牌子->加入购物车，提交订单，支付->取地址-？激活使用
    //2.告诉秘书你要买手机---秘书去买手机--自己使用手机
    //3.洗衣服--面向过程--面向对象--拿盆子--放手--放洗衣粉---放衣服 --手搓
    //4.洗衣机--放衣服 -- 放洗衣液 ----洗衣机  人 衣服 洗衣液 洗衣机
    //面向对象编程的核心：找对象 创建对象 使用对象
    //对象从哪来，是由类生成的
    //类就相当于一个图纸，通过类实例化对象 图纸相当于类，房子相当于对象
    //类其实就是类型
    //一个类可以产生无数个对象

    public static void main3(String[] args) {
        int[][] arry = new int[2][];//不知道有几列，可以进行自己分配，可以不写列号，但是必须写行号
        //int[][] arry = new int[][3];错误写法
        arry[0] = new int[3];
        System.out.println(arry[0]);//null
        System.out.println(arry[1]);//null

        int[][] arry1 = new int[2][3];
        System.out.println(arry1[0]);//指向的是一个新的地址
        System.out.println(arry1[1]);//指向的是一个新的一维数组的地址
    /*    //不规则的二维数组
        int[][] arry = {{1,2},{4,5,6},{7,8,9,10}};
        System.out.println(arry.length);
        System.out.println(arry[0].length);
        System.out.println(arry[1].length);
        System.out.println(arry[2].length);*/


    }
    public static void main2(String[] args) {
        /*int[] arry1 = {1,2,3,4,5,6};//存放的是arr是一个引用变量
        //int[][] arry = {1,2,3,4,5,6};错误写法
        int[][] arry2 = {{1,2,3},{4,5,6}};
        int[][] arry3 = {{1,2},{4,5},{9,8}};
        int[][] arry4 = new int[2][3];//默认都是0
        //int[][] arry5 = new int[2][2]{{1,2},{3,4}};错误写法，写上行，或者写上列都是错误的
        int[][] arry6 = new int[][]{{1,2},{3,4}};//不用写，编译器自己推导得到
        //arry[行][列]
        //二维数组其实就是一个特殊的一维数组
        //arry[0].length;arry[i][j]
        */
        int[][] arry = {{1,2,3},{4,5,6}};

       /*for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println(arry[i][j]+ " ");
            }
        }*/
        /*System.out.println("行数"+arry.length);
        System.out.println("列数"+arry[0].length);
        for (int i = 0; i < arry.length; i++) {
            for (int j = 0; j < arry[i].length; j++) {
                System.out.println(arry[i][j]+" ");
            }
        }*/


    }
}





















/*class Cat{
    public String name;
    public int age;
    public char sex;
    public void eat(){
            System.out.println(name+"吃东西");
    }
    public void sleep(){
            System.out.println(name+"睡觉");
    }
    public void  jump(){
            System.out.println(name+"跳跃");
    }
   *//* public void show(){
        System.out.println("姓名" + name + "年龄" + age + "性别"+ sex);
    }*//*

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "小米";
        cat.age = 3;
        cat.sex = 'm';
        cat.eat();
        System.out.println(cat.toString());
    }
}*/
